package com.example.test003;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 *  自定义的线程池类
 *  成员变量：
 *    1. 任务队列    集合来表示即可（线程安全的集合）
 *    2. 当前线程数量
 *    3. 核心线程数量
 *    4. 最大线程数
 *    5. 任务队列长度
 *   没有设置最大空闲时间
 *
 *  成员方法：
 *    1.提交任务：将任务添加到集合中（如果没有超出任务队列的长度则可以加入到任务队列中）
 *    2.执行任务: 判断当前线程的数量，决定创建核心线程（如果当前线程数量在核心线程数量之下）还是非核心线程（当前线程数量在核心线程数量与最大线程数量之间）
 */
public class MyThreadPool {
//    1. 任务队列  集合来表示即可（线程安全的集合）
//         LinkedList集合是非线程安全的，我们可以使用集合工具类中方法将其转变为线程安全的
    private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());

//     2. 当前线程数量,初始时是0
    private int num;

//     3. 核心线程数量
    private int corePoolSize;

//     4. 最大线程数
    private int maxSize;

//    5. 任务队列长度
    private int workSize;

//    1.提交任务：
    public void submit(Runnable runnable){
//       判断当前集合中任务的数量，是否超出了最大任务数量
        if (tasks.size()>=workSize){
//          TODO  简陋的饱和机制处理
            System.out.println("任务："+runnable+"被丢弃了");
        }else {
            tasks.add(runnable);
//          TODO 执行任务
            execTask(runnable);  //这个地方最好传入线程，不传入任务
        }
    }


//   2.执行任务:
    private void execTask(Runnable runnable) {
//      TODO 判断当前线程池中的线程总数量，是否超出了核心数
        if(num <=corePoolSize){
            MyWorker myWorker = new MyWorker("核心线程："+num,tasks);
//            Thread t = new Thread(myWorker);
//          启动线程
            myWorker.start();
            num++;
        }else if (num < maxSize){
            MyWorker myWorker = new MyWorker("非核心线程："+num,tasks);
//            Thread t = new Thread(myWorker);
//          启动线程
            myWorker.start();
            num++;
        }else {
//            因为我们在execTask之前，已经将任务添加到tasks集合中了，所以说是被缓存了
            System.out.println("任务："+runnable+"被缓存了");
        }
    }

    public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxSize = maxSize;
        this.workSize = workSize;
    }
}
